package com.example.zlw.dem16;

import java.time.*;
import java.time.format.DateTimeFormatter;

/**
 * @program: Zlw
 * @description:
 * @author: 诸葛龙辰
 * @create: 2022-11-07 20:03
 **/
public class DateTest {

        public static void main(String[] args) {
            //指定日期
            LocalDate date=LocalDate.of(2002,12,21);
            //电脑的日期
            LocalDate nowDate=LocalDate.now();
            System.out.println("指定日期："+date);
            System.out.println("电脑日期："+nowDate);
            //指定时间
            LocalTime time=LocalTime.of(12,12,12);
            //电脑的时间
            LocalTime nowTime=LocalTime.now();
            System.out.println("指定时间："+time);
            System.out.println("电脑时间："+nowTime);
            //指定的日期和时间
            LocalDateTime dateTime=LocalDateTime.of(2012,12,12,12,12,12);
            //电脑的日期和时间
            LocalDateTime nowDateTime=LocalDateTime.now();
            System.out.println("指定日期时间："+dateTime);
            System.out.println("电脑日期时间："+nowDateTime);
            System.out.println("==========================================进行时间格式转换====================================");
            System.out.println("这里是没有更改格式的时间："+nowDateTime);
            //日期时间默认格式转换成字符串
            DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy/MM/dd HH/mm/ss");
            String format = dateTimeFormatter.format(nowDateTime);
            System.out.println("这里是格式改变后的日期和时间："+format);
            //将字符串转换成日期时间格式
            DateTimeFormatter dateTimeFormatter1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH-mm-ss");
            LocalDateTime dateTimeFormater=LocalDateTime.parse("2012-12-12 12-12-12",dateTimeFormatter1);
            System.out.println(dateTimeFormater);
            System.out.println("==========================================日期比较====================================");
            System.out.println("指定日期："+date);
            System.out.println("电脑日期："+nowDate);
            Period period=Period.between(date,nowDate);
            System.out.println("相差的年数量"+period.getYears());
            System.out.println("相差的月数量"+period.getMonths());
            System.out.println("相差的天数量"+period.getDays());
            System.out.println("==========================================日期比较====================================");
            System.out.println("指定时间："+time);
            System.out.println("电脑时间："+nowTime);
            Duration duration= Duration.between(time,nowTime);
            System.out.println("相差的小时："+duration.toHours());
            System.out.println("相差的分钟："+duration.toMinutes());
            System.out.println("相差的秒："+duration.getSeconds());
        }
    }



    /**单列模式*/
    /*饿汉模式*/
     class SingleModel {
        //1.创建私有化构造函数
        private SingleModel(){}
        //2.声明一个静态的本类对象
        private static SingleModel singleModel=new SingleModel();
        //3.提供一个静态方法，共外界获取该类对象
        public static  SingleModel getSingleModel(){
            return  singleModel;
        }
    }
    /*懒汉形式No0.1*/
    class SingleModel1 {
        //1.创建私有化构造函数
        private SingleModel1(){}
        //2.声明一个静态的本类对象
        private static SingleModel1 singleModel1=new SingleModel1();
        //3.提供一个静态方法，共外界获取该类对象
        public static  SingleModel1 getSingleModel1(){
            //4.类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
            if(singleModel1==null){
                singleModel1=new SingleModel1();
            }
            return  singleModel1;
        }
    }
    /*通过上面的懒汉形式可以看出再进行多线程的时候会出现线程安全问题，这里就需要我们进一步改变,通过线程中我们加锁的方法来进行解决线程问题*/
    /*懒汉形式No.02*/
    class SingleModel2 {
        //1.创建私有化构造函数
        private SingleModel2(){}
        //2.声明一个静态的本类对象
        private static SingleModel2 singleModel2=new SingleModel2();
        //3.提供一个静态方法，共外界获取该类对象
        public static  SingleModel2 getSingleModel2(){
            //加锁
            synchronized (SingleModel2.class){
                //4.类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
                if(singleModel2==null){
                    singleModel2=new SingleModel2();
                }
                return  singleModel2;
            }
        }
    }
    /*在通过上面加锁解决了我们的线程安全问题并且还保留了懒汉形式，但同时在我们线程中如果一旦初始化完成就不存在了，所以还需要进行更新*/
    /*懒汉形式No.03*/
    class SingleModel3 {
        //1.创建私有化构造函数
        private SingleModel3(){}
        //2.声明一个静态的本类对象
        private static SingleModel3 singleModel3=new SingleModel3();
        //3.提供一个静态方法，共外界获取该类对象
        public static  SingleModel3 getSingleModel3(){
            //在锁的外面进行一个判断，也就是在加一层锁判断
            if(singleModel3==null){
                //加锁
                synchronized (SingleModel3.class){
                    //4.类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
                    if(singleModel3==null){
                        singleModel3=new SingleModel3();
                    }
                }
            }
            return singleModel3;
        }
    }
    /*进行了三次更新后我们再去测试一下，就可以看出这样就会保证了线程安全，也保证了初始化之后的安全问题*/

